Software technique for improving disk write performance on raid system where write sizes are not an integral multiple of number of data disks

ABSTRACT

A method, apparatus, and system of a software technique for improving disk write performance on raid system where write sizes are not an integral multiple of number of data disks are disclosed. In one embodiment, a method includes configuring a queue module to place an amount of data of a write operation into a data buffer module associated with a memory system if writing the amount of data to the memory system would generate a read-modify-write operation to occur, using the data buffer module to temporarily store the amount of data, writing the amount of data from the data buffer module to the memory system. The method may include algorithmically determining the amount of data to place in the data buffer module as a portion of the write operation that may cross a boundary between a striped sector unit (SSU) and/or an other SSU.

FIELD OF TECHNOLOGY

This disclosure relates generally to an enterprise method, a technicalfield of software and/or hardware technology and, in one exampleembodiment, to a software technique for improving disk write performanceon raid system where write sizes are not an integral multiple of numberof data disks.

BACKGROUND

An amount of data may be written to a redundant array of independentdisks (RAID) (e.g., a system of multiple hard drives for sharing,storing and/ or replicating data). The data disk may be divided intosectors (e.g., a minimum addressable read and/or write size). Thegranularity of read and/or write size to the RAID may be a stripe sectorunit (SSU) (e.g., a set of sectors collected one from each data disk ofthe RAID) that may contain a fixed number of sectors.

The amount of data of the write operation may be greater than a singleSSU. Also, the amount of data may require a number of sectors that isnot a multiple of the number of sectors of the SSU. Consequently, thewrite operation may cross a boundary between a SSU and an other SSU. Aportion of the amount of data of the write operation may be partiallywritten into the other SSU. When this occurs, a read-modify-write (RMW)operation (e.g., a sequence of operations that may be performed when aset of data is read, modified and rewritten to a location) may beinitiated. The RMW may require resources and slow the throughput (e.g. arate of data delivery) rate of the RAID.

SUMMARY

A method, apparatus, and system of a software technique for improvingdisk write performance on raid system where write sizes are not anintegral multiple of number of data disks are disclosed. In one aspect,a method includes configuring a queue module to place an amount of dataof a write operation into a data buffer module associated with a memorysystem if writing the amount of data to the memory system would generatea read-modify-write operation to occur, using the data buffer module totemporarily store the amount of data, and writing the amount of datafrom the data buffer module to the memory system.

The memory system may be a redundant array of independent disks (RAID)module. The data buffer module may be a software cache module. Thesoftware cache module may be implemented as a hash table. The RAIDmodule may have a striped sector unit value that may not be a multipleof a number of sectors of the write operation.

The method may include algorithmically determining the amount of data toplace in the data buffer module as a portion of the write operation thatmay cross a boundary between a striped sector unit (SSU) and/or an otherSSU. The method may also include determining a presence of the amount ofdata in the data buffer module when an other write operation may be inthe queue module. The method may append the amount of data in the databuffer module to the other write operation. The amount of data may beappended to the beginning of the other write operation and/or an end ofthe other write operation.

The amount of data may be written to the memory system if a read requestoccurs for the amount of data while it may be temporarily stored in thedata buffer module. The method may include examining the amount of datain the data buffer module for a set of data that may duplicate an otherset of data of the other write operation. In addition, the method maydiscard the set of data that duplicates the other set of data of theother write operation. The memory system may be a single-disk system.Multiple write operations to a single sector may be temporarily storedin the data buffer module until a full sector may be gathered. A singlewrite operation containing the data of the write operations may beperformed to the memory system when the full sector is gathered.

In another aspect, a system includes a redundant array of independentdisks (RAID) module, a queue module associated with the redundant arrayof independent disks (RAID) module to place an amount of data of a writeoperation in a data buffer module if writing the amount of data to theRAID module would cause the write operation to overlap an interfacebetween a striped sector unit (SSU) of the RAID module and an other SSUof the RAID module, the data buffer module associated with the RAIDmodule to temporarily store the amount of data from the queue module,and a write module to write the amount of data temporarily stored in thedata buffer module to the RAID module.

The write module may write the amount of data temporarily stored in thedata buffer module to a single SSU of the RAID module. The data buffermodule may use a soft ware cache implemented as a hash table to storethe amount of data. The RAID module may have a number of data disks thatmay not divide the sectors to be written integrally. The write modulemay append a data from the data buffer module is appended to an otherwrite operation. The amount of data may be written to the memory systemif a read request occurs for the amount of data while it may betemporarily stored in the data buffer module. The amount of data may bewritten to the memory system if a read request occurs for the amount ofdata while it may be temporarily stored in the data buffer module.

The system may include a de-duplicator module to examine the data buffermodule for a set of data that duplicates an other set of data of theother write operation. In addition, the system may include a removalmodule to discard the set of data that duplicates the other set of dataof the other write operation. The system may also include the redundantarray of independent disks (RAID) module has a single data disk. Writeoperations to a single sector may be temporarily stored in the databuffer module until a full sector may be gathered. A single writeoperation may be performed when the full sector is gathered.

In yet another aspect, a method includes determining if a portion of adata write overlaps an interface between a striped sector unit (SSU) toa redundant array of independent disks (RAID) and an other SSU of theRAID, temporarily storing the portion of a data write that overlaps theinterface into a software cache, and appending the portion of the datawrite in the software cache to an other data write.

The method may include determining if a portion of the other data writeoverlaps an other interface between the other SSU to the RAID and/or anadditional SSU of the RAID. In addition, the method may temporarilystore the portion of the other data write that overlaps the otherinterface into the software cache. The method may also append theportion of the other data write in the software cache to an additionaldata write.

The methods, systems, and apparatuses disclosed herein may beimplemented in any means for achieving various aspects, and may beexecuted in a form of a machine-readable medium embodying a set ofinstructions that, when executed by a machine, cause the machine toperform any of the operations disclosed herein. Other features will beapparent from the accompanying drawings and from the detaileddescription that follows.

BRIEF DESCRIPTION OF THE DRAWINGS

Example embodiments are illustrated by way of example and not limitationin the figures of the accompanying drawings, in which like referencesindicate similar elements and in which:

FIG. 1 is a system view of data buffer module 106 communicating with thequeue module and the RAID module to avoid read-modify-write (RMW)operation, according to one embodiment.

FIG. 2 is an exploded view of a data disk of a RAID system, according toone embodiment.

FIG. 3 is a system view illustrating a data on queue in order of arrivalwhen the packet arrives that has to be written into the memory locationsin RAID module, according to one embodiment.

FIG. 4 is a system view illustrating storing portions of data in asoftware cache and later retrieving them to be written along withcontiguous data to avoid the RMW, according to one embodiment.

FIG. 5 is a diagrammatic system view 500 of a data processing system inwhich any of the embodiments disclosed herein may be performed,according to on embodiment.

FIG. 6 is a process flow of configuring a queue module to place anamount of data of a write operation into a data buffer module associatedwith a memory system, according to one embodiment.

FIG. 7 is a process flow of determining if a portion of a data writeoverlaps an interface between a striped sector unit (SSU) to a redundantarray of independent disks (RAID), according to one embodiment.

Other features of the present embodiments will be apparent from theaccompanying drawings and from the detailed description that follows.

DETAILED DESCRIPTION

A method, apparatus, and system of a software technique for improvingdisk write performance on raid system where write sizes are not anintegral multiple of number of data disks are disclosed. Although thepresent embodiments have been described with reference to specificexample embodiments, it will be evident that various modifications andchanges may be made to these embodiments without departing from thebroader spirit and scope of the various embodiments.

In one embodiment, a method includes configuring a queue module (e.g.,the queue module 104 of FIG. 1) to place an amount of data of a writeoperation into a data buffer module (e.g., the data buffer module 106 ofFIG. 1) associated with a memory system (e.g., may be the RAID module102 of FIG. 1) if writing the amount of data to the memory system (e.g.,using the write module 110 of FIG. 1) would generate a read-modify-writeoperation to occur, using the data buffer module 106 to temporarilystore the amount of data, writing the amount of data from the databuffer module 106 to the memory system (e.g., may be the RAID module 102of FIG. 1).

In another embodiment, a system includes a redundant array ofindependent disks (RAID) module (e.g., the redundant array ofindependent disks (RAID) module 102 of FIG. 1), a queue module (e.g.,the queue module 104 of FIG. 1) associated with the redundant array ofindependent disks (RAID) module 102 to place an amount of data of awrite operation in a data buffer module (e.g., the data buffer module106 of FIG. 1) if writing the amount of data to the RAID module 102would cause the write operation to overlap an interface between astriped sector unit (SSU) (e.g., the striped sector unit (SSU) 118 ofFIG. 1) of the RAID module 102 and an other SSU of the RAID module 102,the data buffer module 106 associated with the RAID module 102 totemporarily store the amount of data from the queue module 104, and awrite module (e.g., the write module 110 of FIG. 1) to write the amountof data temporarily stored in the data buffer module 106 to the RAIDmodule 102.

In yet another embodiment, a method includes determining if a portion ofa data write overlaps an interface between a striped sector unit (SSU)(e.g., the striped sector unit (SSU) 118 of FIG. 1) to a redundant arrayof independent disks (RAID) and an other SSU of the RAID, temporarilystoring the portion of a data write that overlaps the interface into asoftware cache, and appending the portion of the data write in thesoftware cache to an other data write (e.g., using the data buffermodule (e.g., the software cache module) 106 of FIG. 1).

FIG. 1 is a system view of data buffer module 106 communicating with thequeue module and the RAID module to avoid read-modify-write (RMW)operation, according to one embodiment. Particularly, FIG. 1 illustratesa RAID module 102, a queue module 104, a data buffer module (e.g.,software cache module) 106, a data disk 108A-N, a write module 110, aremoval module 112, a de-duplication module 114, a parity disk 116, aSSU 118, a sector 120, and network 122, according to one embodiment.

The RAID module 102 may be the memory system (e.g., hard disk, server,etc.) that may have a striped sector unit (SSU), and data disks (e.g.,in the raid module 102) may receive the data from the sources (e.g., maybe from network, from the data buffer, etc.). The queue module 104(e.g., temporary stack, accumulator, etc.) may be a module that may beassociated with the RAID module 102 which may place an amount of data ofa write operation (e.g., temporarily) in the data buffer module 106. Thedata buffer module (e.g., software cache module) 106 may be associatedwith the RAID module 102 that may temporarily store the amount of data(e.g., that may be required to avoid RMW) from the queue module 104.

The data disk 108A-N may be the disk (e.g., may be divided into sectors)in which the data arrives from the source (e.g., network, etc.) into thepreprogrammed hardware queues and from there it may directly written tothe disk (e.g., may be the RAID). The write module 110 may be the modulethat may write the amount of data which may be temporarily stored in thedata buffer module 106 to the RAID module 102. The removal module 112may be the module that may remove the set of data which may duplicatethe other set of data of the other write operation. The de-duplicationmodule 114 may examine the data buffer module for 106 the set of datathat may duplicate the other set of data of the other write operation.

The parity disk 116 may be a part of RAID module 102 that may store theparity data that may be generated from the special operation (e.g., thatmay be specific to the particular RAID technology like the XORoperation, etc.) which may be used to generate the lost or corrupteddata. The SSU (Stripe Sector Unit) 118 may be a set of memory location(e.g., part of a sector) that may be collected from each disk arraydrive (e.g., for a 4-disk RAID5 system the SSU may be 3, etc.) forstoring the data logically. The sector 120 may be the addressable (e.g.,read-write) size of memory locations (e.g., may be like 512 Bytes) thatmay be used to address the memory locations to store the data logically.The network 122 may be communication system that may enable the devicesthat are connected (e.g., may be wired or wireless) to communicate witheach other through a medium (e.g., LAN, WAN, Bluetooth, WiFi, ZigBee,etc.).

In example embodiment, the RAID module 102 may include the data disk108A-N, the parity disk 116, the SSU 118, and the sector 120. The queuemodule 104 that may include the de-duplication module may place anamount of data of a write operation into the data buffer module 106. Thedata buffer module (e.g., software cache module) 106 that includes thewrite module 110 and the removal module 112. The removal module 112 maytemporarily store the amount of data. The RAID module 102 may beconnected to the queue module 104, and the data buffer module (e.g.,software cache module) 106 to avoid RMW (Read-Modify-Write).

In one embodiment, the queue module 104 may be configured to place theamount of data of the write operation into the data buffer module 106associated with the memory system (e.g., may be the RAID module 102 ofFIG. 1) if writing the amount of data to the memory system may generatethe read-modify-write operation to occur. The data buffer module 106 maybe used to temporarily store the amount of data. The amount of data maybe written from the data buffer module 106 to the memory system.

The memory system (e.g., may be the RAID module 102 of FIG. 1) may bethe redundant array of independent disks (RAID) module 102. The databuffer module 106 may be the software cache module. The software cachemodule (e.g., may be the data buffer module 106 of FIG. 1) may beimplemented as the hash table. The RAID module 102 has the stripedsector unit value that may not be the multiple of the number of sectorsof the write operation. The amount of data may be algorithmicallydetermined to place in the data buffer module 106 as the portion of thewrite operation that would cross the boundary between the striped sectorunit (SSU) 118 and the other SSU. The presence of the amount of data maybe determined in the data buffer module 106 when the other writeoperation is in the queue module 104.

The amount of data may be appended in the data buffer module 106 to theother write operation. The amount of data may be appended to thebeginning of the other write operation and/or the end of the other writeoperation. The amount of data may be written to the memory system (e.g.,using the write module 110 of the data buffer module 106 as illustratedin FIG. 1) if the read request occurs for the amount of data while itmay be temporarily stored in the data buffer module 106. The amount ofdata may be examined in the data buffer module 106 for the set of datathat duplicates the other set of data of the other write operation(e.g., using the de-duplication module 114 of the queue module 104 ofFIG. 1).

The set of data that duplicates the other set of data of the other writeoperation may be discarded. The memory system may be the single-disksystem. The write operations to the single sector may be temporarilystored in the data buffer module 106 until the full sector is gathered.The single write operation containing the data of the write operationsmay be performed to the memory system (e.g., may be the RAID module 102of FIG. 1) when the full sector is gathered.

The queue module 104 associated with the redundant array of independentdisks (RAID) module 102 may place the amount of data of the writeoperation in the data buffer module 106 if writing the amount of data tothe RAID module 102 may cause the write operation to overlap theinterface between the striped sector unit (SSU) 118 of the RAID module102 and/or the other SSU of the RAID module 102. The data buffer module106 associated with the RAID module 102 may temporarily store the amountof data from the queue module 104. The write module 110 may write theamount of data temporarily stored in the data buffer module 106 to theRAID module 102.

The write module 110 may write the amount of data temporarily stored inthe data buffer module 106 to the single SSU of the RAID module 102. Thedata buffer module 106 may use the soft ware cache implemented as thehash table to store the amount of data. The RAID module 102 may have thenumber of data disks 108A-N. The write module 110 appends the data fromthe data buffer module 106 may be appended to the other write operation.The amount of data may be written to the memory system if the readrequest occurs for the amount of data while it may be temporarily storedin the data buffer module 106. The amount of data may be written to thememory system if the read request occurs for the amount of data while itmay be temporarily stored in the data buffer module 106.

The de-duplication module 114 may examine the data buffer module 106 forthe set of data that duplicates the other set of data of the other writeoperation. The removal module 112 may discard the set of data thatduplicates the other set of data of the other write operation. Theredundant array of independent disks (RAID) module 102 may have thesingle data disk. The write operations to the single sector may betemporarily stored in the data buffer module 106 until the full sectoris gathered. The single write operation may be performed when the fullsector is gathered.

It may be determined if the portion of the data write overlaps theinterface between the striped sector unit (S SU) 118 to the redundantarray of independent disks (RAID) and the other SSU of the RAID. Theportion of the data write that overlaps the interface may be temporarilystored into the software cache (e.g., using the data buffer module(e.g., the software cache module) 106 of FIG. 1). The portion of thedata write (e.g., may be the data write A (e.g., data write) 204A ofFIG. 2) in the software cache may be appended to the other data write(e.g., may be the data write B (e.g., the another data write) 204B ofFIG. 2). It may be determined if the portion of the other data writeoverlaps the other interface between the other SSU to the RAID and theadditional SSU of the RAID. The portion of the other data write 204Bthat overlaps the other interface may be temporarily stored into thesoftware cache. The portion of the other data write 204B in the softwarecache may be appended to the additional data write.

FIG. 2 is an exploded view of the data disk of a RAID system, accordingto one embodiment. Particularly, FIG. 2 illustrates the RAID module 102,the data disk 108A-N, the SSU 118A-N, a data to be temporarily stored indata buffer 202, a data write A (e.g., data write) 204A, a data write(e.g., another data write) 204B, and a boundary between SSU A & SSU B206, according to one embodiment.

The data to be temporarily stored in data buffer 202 may be the amountof data that may be temporarily stored in the data buffer module untilthe full stripe may be gathered for the performance of the writeoperation to the memory system (e.g., may be the RAID module). The datawrite A (e.g., data write) 204A may be a set of data packets (e.g., ‘A’as illustrated in FIG. 2) that may be written into the data disk 108A.The data write B (e.g., another data write) 204B may be a set of datapackets (e.g., ‘A’ as illustrated in FIG. 2) that may be written intothe data disk 108N that may be a start of data writing for nextcontinuous set of data packets. The boundary between SSU A & SSU B 206may be gap between the two SSU's (e.g., that may cause RMW).

In example embodiment, the RAID module 102 may include the data disk108A-N, and the SSU 118A-N. The data disk 108A-N may include the data tobe temporarily stored in data buffer 202 (e.g., D, D, E, A, etc.), thedata write A (e.g., data write) 204A (e.g., A, B, C, etc.), and the datawrite (e.g., another data write) 204B (e.g., A, etc.). The RAID module102 may include the SSU 118A-N.

FIG. 3 is a system view illustrating a data on queue in order of arrivalwhen the packet arrives that has to be written into the memory locationsin RAID module, according to one embodiment. Particularly, FIG. 3illustrates a packet 1-4 302A-D, according to one embodiment.

The packet 1-4 302A-D may be a logical group (e.g., large data brokeninto small units for transmitting over network) of data (e.g., may bethe amount of data that the application may transfer in one request) ofa certain size in bytes (e.g., the data may be written is 64 KB (KiloByte) in size).

In example embodiment, FIG. 3 illustrates incoming data packets that mayhave to be stored in the memory locations. A part of data cannot bedirectly written into the memory locations as that may cause the data inthe previous memory location to be completely erased and thus the RMWprocedure is followed. The FIG. 3 may also illustrate the exampleembodiment, where the data packets coming from the sources (e.g.,network) are written into the memory locations. The Figure alsoillustrates the part of data that may cause the RMW operation that mayhamper the performance of the system dependent on it.

FIG. 4 is a system view illustrating storing portions of data in asoftware cache and later retrieving them to be written along withcontiguous data to avoid the RMW, according to one embodiment.Particularly, FIG. 4 illustrates the packet 1-4 302A-D, and a softwarecache (e.g., data buffer module) 402, according to one embodiment.

The software cache (e.g., data buffer module) 402 (e.g.,. may be atemporary storage location implemented through software) may be used bythe data buffer module 106 to implement a hash table that may store theamount of data and connect the portion of data write to the other datawrite.

In example embodiment, the packet 1 302A of 64 KB (e.g., 128 sectorsstart at sector 1). Out of these, 126 sectors may be written to diskswithout any RMW. The writing sectors 127 and 128 may incur RMW as theymay partially fill the SSU. So they may read from the queue and storedin a software cache which may be implemented as a hash table. The packet2 302B of 64 KB consists of sectors 257 to 384. Sectors 257 and 258 maypartially fill the SSU and hence may be stored in the cache. The rest ofsectors (259 to 384) may be written to the disks without any RMW. Thepacket 3 302C consists of sectors 129 to 256. At this point sectors 127and 128 may be fetched from the cache and written before the currentdata (e.g., may be before data of sector 129), and the sectors 257 and258 may be fetched and written after current data (e.g., after data ofsector 256. So now sectors 127 to 258 may be written to disks withoutany RMW).

FIG. 5 is a diagrammatic system view 500 of a data processing system inwhich any of the embodiments disclosed herein may be performed,according to one embodiment. Particularly, the diagrammatic system view500 of FIG. 5 illustrates a processor 502, a main memory 504, a staticmemory 506, a bus 508, a video display 510, an alpha-numeric inputdevice 512, a cursor control device 514, a drive unit 516, a signalgeneration device 518, a network interface device 520, a machinereadable medium 522, instructions 524, and a network 526, according toone embodiment.

The diagrammatic system view 500 may indicate a personal computer and/orthe data processing system in which one or more operations disclosedherein are performed. The processor 502 may be a microprocessor, a statemachine, an application specific integrated circuit, a fieldprogrammable gate array, etc. (e.g., Intel® Pentium® processor). Themain memory 504 may be a dynamic random access memory and/or a primarymemory of a computer system.

The static memory 506 may be a hard drive, a flash drive, and/or othermemory information associated with the data processing system. The bus508 may be an interconnection between various circuits and/or structuresof the data processing system. The video display 510 may providegraphical representation of information on the data processing system.The alpha-numeric input device 512 may be a keypad, a keyboard and/orany other input device of text (e.g., a special device to aid thephysically handicapped).

The cursor control device 514 may be a pointing device such as a mouse.The drive unit 516 may be the hard drive, a storage system, and/or otherlonger term storage subsystem. The signal generation device 518 may be abios and/or a functional operating system of the data processing system.The network interface device 520 may be a device that performs interfacefunctions such as code conversion, protocol conversion and/or bufferingrequired for communication to and from the network 526. The machinereadable medium 522 may provide instructions on which any of the methodsdisclosed herein may be performed. The instructions 524 may providesource code and/or data code to the processor 502 to enable any one ormore operations disclosed herein.

FIG. 6 is a process flow of configuring a queue module (e.g., the queuemodule 104 of FIG. 1) to place an amount of data of a write operationinto a data buffer module (e.g., the data buffer module 106 of FIG. 1)associated with a memory system (e.g., may be the RAID module 102 ofFIG. 1), according to one embodiment. In operation 602, the queue module104 may be configured to place an amount of data of a write operationinto the data buffer module 106 associated with the memory system (e.g.,may be the RAID module 102 of FIG. 1) if writing the amount of data tothe memory system may generate a read-modify-write operation to occur.In operation 604, the data buffer module 106 may be used to temporarilystore the amount of data. In operation 606, the amount of data may bewritten from the data buffer module 106 to the memory system (e.g., maybe the RAID module 102 of FIG. 1).

The memory system may be a redundant array of independent disks (RAID)module 102. The data buffer module 106 may be a software cache module.The software cache module may be implemented as a hash table. The RAIDmodule 102 may have a striped sector unit value that may not be amultiple of a number of sectors of the write operation.

In operation 608, the amount of data may be algorithmically determinedto place in the data buffer module 106 as a portion of the writeoperation that may cross a boundary between a striped sector unit (SSU)and a other SSU (e.g., may be the boundary between a striped sector unit(SSU) and a other SSU 206 of FIG. 2). In operation 610, a presence ofthe amount of data may be determined in the data buffer module 106 whenan other write operation is in the queue module 104. In operation 612,the amount of data may be appended in the data buffer module 106 to theother write operation. The amount of data may be appended to thebeginning of the other write operation and/or an end of the other writeoperation. The amount of data may be written to the memory system if aread request occurs for the amount of data while it may be temporarilystored in the data buffer module 106.

In operation 614, the amount of data may be examined in the data buffermodule 106 for a set of data that duplicates an other set of data of theother write operation. In operation 616, the set of data that duplicatesthe other set of data of the other write operation may be discarded. Thememory system may be a single-disk system. A write operation to a singlesector may be temporarily stored in the data buffer module 106 until afull sector is gathered. A single write operation containing the data ofthe write operations may be performed to the memory system when the fullsector is gathered.

FIG. 7 is a process flow of determining if a portion of a data write(e.g., may be the data drive A (e.g., data write) 204A, and the datawrite (e.g., another data write) 204B of FIG. 2) overlaps an interfacebetween a striped sector unit (SSU) (e.g., the striped sector unit (SSU)118 of FIG. 1) to a redundant array of independent disks (RAID) (e.g.,the redundant array of independent disks (RAID) 102 of FIG. 1),according to one embodiment. In operation 702, it may be determined(e.g., using the queue module 104 of FIG. 1) if a portion of a datawrite overlaps an interface between the striped sector unit (SSU) to aredundant array of independent disks (RAID) and an other SSU of theRAID. In operation 704, the portion of the data write that overlaps theinterface may be temporarily stored into a software cache (e.g., usingthe data buffer module (e.g., software cache module) 106 of FIG. 1). Inoperation 706, the portion of the data write in the software cache maybe appended (e.g., using the write module 110 of FIG. 1) to an otherdata write.

In operation 708, it may be determined (e.g., using some specifiedalgorithms) if a portion of the other data write overlaps an otherinterface between the other SSU to the RAID and an additional SSU of theRAID. In operation 710, the portion of the other data write thatoverlaps the other interface may be temporarily stored into the softwarecache (e.g., using the data buffer module (e.g., software cache module)106 of FIG. 1). In operation 712, the portion of the other data write inthe software cache may be appended (e.g., using the write module 110 ofFIG. 1) to an additional data write.

Although the present embodiments have been described with reference tospecific example embodiments, it will be evident that variousmodifications and changes may be made to these embodiments withoutdeparting from the broader spirit and scope of the various embodiments.For example, the various devices, modules, analyzers, generators, etc.described herein may be enabled and operated using hardware circuitry(e.g., CMOS based logic circuitry), firmware, software and/or anycombination of hardware, firmware, and/or software (e.g., embodied in amachine readable medium). For example, the various electrical structureand methods may be embodied using transistors, logic gates, andelectrical circuits (e.g., application specific integrated (ASIC)circuitry and/or in Digital Signal Processor (DSP) circuitry).

Particularly, the RAID module 102, the queue module 104, the data buffermodule (e.g., software cache module) 106, the write module 110, theremoval module 112, the de-duplication module 114 of FIG. 1-7 may beenabled using software and/or using transistors, logic gates, andelectrical circuits (e.g., application specific integrated ASICcircuitry) such as a RAID module circuit, a queue circuit, a data buffercircuit (e.g., software cache circuit), a write circuit, a removalcircuit, a de-duplication circuit, and other circuit.

In addition, it will be appreciated that the various operations,processes, and methods disclosed herein may be embodied in amachine-readable medium and/or a machine accessible medium compatiblewith a data processing system (e.g., a computer system), and may beperformed in any order (e.g., including using means for achieving thevarious operations). Accordingly, the specification and drawings are tobe regarded in an illustrative rather than a restrictive sense.

1. A method comprising: configuring a queue module to place an amount ofdata of a write operation into a data buffer module associated with amemory system if writing the amount of data to the memory system wouldgenerate a read-modify-write operation to occur; using the data buffermodule to temporarily store the amount of data; and writing the amountof data from the data buffer module to the memory system.
 2. The methodof claim 1 wherein the memory system is a redundant array of independentdisks (RAID) module.
 3. The method of claim 2 wherein the data buffermodule is a software cache module.
 4. The method of claim 3 wherein thesoftware cache module is implemented as a hash table.
 5. The method ofclaim 2 wherein the RAID module has a striped sector unit value that isnot a multiple of a number of sectors of the write operation.
 6. Themethod of claim 5 further comprising algorithmically determining theamount of data to place in the data buffer module as a portion of thewrite operation that would cross a boundary between a striped sectorunit (SSU) and an other SSU.
 7. The method of claim 6: furthercomprising determining a presence of the amount of data in the databuffer module when an other write operation is in the queue module;further comprising appending the amount of data in the data buffermodule to the other write operation; and wherein the amount of data isappended to at least one of the beginning of the other write operationand an end of the other write operation.
 8. The method of claim 7wherein the amount of data is written to the memory system if a readrequest occurs for the amount of data while it is temporarily stored inthe data buffer module.
 9. The method of claim 8 further comprising:examining the amount of data in the data buffer module for a set of datathat duplicates an other set of data of the other write operation; anddiscarding the set of data that duplicates the other set of data of theother write operation.
 10. The method of claim 9 wherein a computerreadable medium comprising computer executable instructions is adaptedto perform the method of claim
 9. 11. The method of claim 1: wherein thememory system is a single-disk system; wherein a plurality of writeoperations to a single sector are temporarily stored in the data buffermodule until a full sector is gathered; and wherein in a single writeoperation containing the data of the plurality of the write operationsis performed to the memory system when the full sector is gathered. 12.A system comprising: a redundant array of independent disks (RAID)module; a queue module associated with the redundant array ofindependent disks (RAID) module to place an amount of data of a writeoperation in a data buffer module if writing the amount of data to theRAID module would cause the write operation to overlap an interfacebetween a striped sector unit (SSU) of the RAID module and an other SSUof the RAID module; the data buffer module associated with the RAIDmodule to temporarily store the amount of data from the queue module;and a write module to write the amount of data temporarily stored in thedata buffer module to the RAID module.
 13. The system of claim 12wherein the write module writes the amount of data temporarily stored inthe data buffer module to a single SSU of the RAID module.
 14. Thesystem of claim 13: wherein the data buffer module uses a soft warecache implemented as a hash table to store the amount of data; andwherein the RAID module has an odd number of data disks.
 15. The systemof claim 14 wherein the write module appends a data from the data buffermodule is appended to an other write operation.
 16. The system of claim15: wherein the amount of data is written to the memory system if a readrequest occurs for the amount of data while it is temporarily stored inthe data buffer module; and wherein the amount of data is written to thememory system if a read request occurs for the amount of data while itis temporarily stored in the data buffer module.
 17. The system of claimof 12: a de-duplication module to examine the data buffer module for aset of data that duplicates an other set of data of the other writeoperation; and a removal module to discard the set of data thatduplicates the other set of data of the other write operation.
 18. Thesystem of claim 17: wherein the redundant array of independent disks(RAID) module has a single data disk; wherein a plurality of writeoperations to a single sector are temporarily stored in the data buffermodule until a full sector is gathered; and wherein in a single writeoperation is performed when the full sector is gathered.
 19. A methodcomprising: determining if a portion of a data write overlaps aninterface between a striped sector unit (SSU) to a redundant array ofindependent disks (RAID) and an other SSU of the RAID; temporarilystoring the portion of a data write that overlaps the interface into asoftware cache; and appending the portion of the data write in thesoftware cache to an other data write.
 20. The method of claim 19:determining if a portion of the other data write overlaps an otherinterface between the other SSU to the RAID and an additional SSU of theRAID; temporarily storing the portion of the other data write thatoverlaps the other interface into the software cache; and appending theportion of the other data write in the software cache to an additionaldata write.